home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_deque.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  24KB  |  691 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. from collections import deque
  5. import unittest
  6. from test import test_support
  7. from weakref import proxy
  8. import copy
  9. import cPickle as pickle
  10. from cStringIO import StringIO
  11. import random
  12. import os
  13. BIG = 100000
  14.  
  15. def fail():
  16.     raise SyntaxError
  17.     yield 1
  18.  
  19.  
  20. class TestBasic(unittest.TestCase):
  21.     
  22.     def test_basics(self):
  23.         d = deque(xrange(100))
  24.         d.__init__(xrange(100, 200))
  25.         for i in xrange(200, 400):
  26.             d.append(i)
  27.         
  28.         for i in reversed(xrange(-200, 0)):
  29.             d.appendleft(i)
  30.         
  31.         self.assertEqual(list(d), range(-200, 400))
  32.         self.assertEqual(len(d), 600)
  33.         left = [ d.popleft() for i in xrange(250) ]
  34.         self.assertEqual(left, range(-200, 50))
  35.         self.assertEqual(list(d), range(50, 400))
  36.         right = [ d.pop() for i in xrange(250) ]
  37.         right.reverse()
  38.         self.assertEqual(right, range(150, 400))
  39.         self.assertEqual(list(d), range(50, 150))
  40.  
  41.     
  42.     def test_comparisons(self):
  43.         d = deque('xabc')
  44.         d.popleft()
  45.         for e in [
  46.             d,
  47.             deque('abc'),
  48.             deque('ab'),
  49.             deque(),
  50.             list(d)]:
  51.             if type(d) == type(e):
  52.                 pass
  53.             self.assertEqual(d == e, list(d) == list(e))
  54.             if type(d) == type(e):
  55.                 pass
  56.             self.assertEqual(d != e, not (list(d) == list(e)))
  57.         
  58.         args = map(deque, ('', 'a', 'b', 'ab', 'ba', 'abc', 'xba', 'xabc', 'cba'))
  59.         for x in args:
  60.             for y in args:
  61.                 self.assertEqual(x == y, list(x) == list(y), (x, y))
  62.                 self.assertEqual(x != y, list(x) != list(y), (x, y))
  63.                 self.assertEqual(x < y, list(x) < list(y), (x, y))
  64.                 self.assertEqual(x <= y, list(x) <= list(y), (x, y))
  65.                 self.assertEqual(x > y, list(x) > list(y), (x, y))
  66.                 self.assertEqual(x >= y, list(x) >= list(y), (x, y))
  67.                 self.assertEqual(cmp(x, y), cmp(list(x), list(y)), (x, y))
  68.             
  69.         
  70.  
  71.     
  72.     def test_extend(self):
  73.         d = deque('a')
  74.         self.assertRaises(TypeError, d.extend, 1)
  75.         d.extend('bcd')
  76.         self.assertEqual(list(d), list('abcd'))
  77.  
  78.     
  79.     def test_extendleft(self):
  80.         d = deque('a')
  81.         self.assertRaises(TypeError, d.extendleft, 1)
  82.         d.extendleft('bcd')
  83.         self.assertEqual(list(d), list(reversed('abcd')))
  84.         d = deque()
  85.         d.extendleft(range(1000))
  86.         self.assertEqual(list(d), list(reversed(range(1000))))
  87.         self.assertRaises(SyntaxError, d.extendleft, fail())
  88.  
  89.     
  90.     def test_getitem(self):
  91.         n = 200
  92.         d = deque(xrange(n))
  93.         l = range(n)
  94.         for i in xrange(n):
  95.             d.popleft()
  96.             l.pop(0)
  97.             if random.random() < 0.5:
  98.                 d.append(i)
  99.                 l.append(i)
  100.             
  101.             for j in xrange(1 - len(l), len(l)):
  102.                 if not d[j] == l[j]:
  103.                     raise AssertionError
  104.             
  105.         
  106.         d = deque('superman')
  107.         self.assertEqual(d[0], 's')
  108.         self.assertEqual(d[-1], 'n')
  109.         d = deque()
  110.         self.assertRaises(IndexError, d.__getitem__, 0)
  111.         self.assertRaises(IndexError, d.__getitem__, -1)
  112.  
  113.     
  114.     def test_setitem(self):
  115.         n = 200
  116.         d = deque(xrange(n))
  117.         for i in xrange(n):
  118.             d[i] = 10 * i
  119.         
  120.         []([], [ 10 * i for i in xrange(n) ])
  121.         l = list(d)
  122.         for i in xrange(1 - n, 0, -1):
  123.             d[i] = 7 * i
  124.             l[i] = 7 * i
  125.         
  126.         self.assertEqual(list(d), l)
  127.  
  128.     
  129.     def test_delitem(self):
  130.         n = 500
  131.         d = deque(xrange(n))
  132.         self.assertRaises(IndexError, d.__delitem__, -n - 1)
  133.         self.assertRaises(IndexError, d.__delitem__, n)
  134.         for i in xrange(n):
  135.             self.assertEqual(len(d), n - i)
  136.             j = random.randrange(-len(d), len(d))
  137.             val = d[j]
  138.             self.assert_(val in d)
  139.             del d[j]
  140.             self.assert_(val not in d)
  141.         
  142.         self.assertEqual(len(d), 0)
  143.  
  144.     
  145.     def test_rotate(self):
  146.         s = tuple('abcde')
  147.         n = len(s)
  148.         d = deque(s)
  149.         d.rotate(1)
  150.         self.assertEqual(''.join(d), 'eabcd')
  151.         d = deque(s)
  152.         d.rotate(-1)
  153.         self.assertEqual(''.join(d), 'bcdea')
  154.         d.rotate()
  155.         self.assertEqual(tuple(d), s)
  156.         for i in xrange(n * 3):
  157.             d = deque(s)
  158.             e = deque(d)
  159.             d.rotate(i)
  160.             for j in xrange(i):
  161.                 e.rotate(1)
  162.             
  163.             self.assertEqual(tuple(d), tuple(e))
  164.             d.rotate(-i)
  165.             self.assertEqual(tuple(d), s)
  166.             e.rotate(n - i)
  167.             self.assertEqual(tuple(e), s)
  168.         
  169.         for i in xrange(n * 3):
  170.             d = deque(s)
  171.             e = deque(d)
  172.             d.rotate(-i)
  173.             for j in xrange(i):
  174.                 e.rotate(-1)
  175.             
  176.             self.assertEqual(tuple(d), tuple(e))
  177.             d.rotate(i)
  178.             self.assertEqual(tuple(d), s)
  179.             e.rotate(i - n)
  180.             self.assertEqual(tuple(e), s)
  181.         
  182.         d = deque(s)
  183.         e = deque(s)
  184.         e.rotate(BIG + 17)
  185.         dr = d.rotate
  186.         for i in xrange(BIG + 17):
  187.             dr()
  188.         
  189.         self.assertEqual(tuple(d), tuple(e))
  190.         self.assertRaises(TypeError, d.rotate, 'x')
  191.         self.assertRaises(TypeError, d.rotate, 1, 10)
  192.         d = deque()
  193.         d.rotate()
  194.         self.assertEqual(d, deque())
  195.  
  196.     
  197.     def test_len(self):
  198.         d = deque('ab')
  199.         self.assertEqual(len(d), 2)
  200.         d.popleft()
  201.         self.assertEqual(len(d), 1)
  202.         d.pop()
  203.         self.assertEqual(len(d), 0)
  204.         self.assertRaises(IndexError, d.pop)
  205.         self.assertEqual(len(d), 0)
  206.         d.append('c')
  207.         self.assertEqual(len(d), 1)
  208.         d.appendleft('d')
  209.         self.assertEqual(len(d), 2)
  210.         d.clear()
  211.         self.assertEqual(len(d), 0)
  212.  
  213.     
  214.     def test_underflow(self):
  215.         d = deque()
  216.         self.assertRaises(IndexError, d.pop)
  217.         self.assertRaises(IndexError, d.popleft)
  218.  
  219.     
  220.     def test_clear(self):
  221.         d = deque(xrange(100))
  222.         self.assertEqual(len(d), 100)
  223.         d.clear()
  224.         self.assertEqual(len(d), 0)
  225.         self.assertEqual(list(d), [])
  226.         d.clear()
  227.         self.assertEqual(list(d), [])
  228.  
  229.     
  230.     def test_repr(self):
  231.         d = deque(xrange(200))
  232.         e = eval(repr(d))
  233.         self.assertEqual(list(d), list(e))
  234.         d.append(d)
  235.         self.assert_('...' in repr(d))
  236.  
  237.     
  238.     def test_print(self):
  239.         d = deque(xrange(200))
  240.         d.append(d)
  241.         
  242.         try:
  243.             fo = open(test_support.TESTFN, 'wb')
  244.             print >>fo, d,
  245.             fo.close()
  246.             fo = open(test_support.TESTFN, 'rb')
  247.             self.assertEqual(fo.read(), repr(d))
  248.         finally:
  249.             fo.close()
  250.             os.remove(test_support.TESTFN)
  251.  
  252.  
  253.     
  254.     def test_init(self):
  255.         self.assertRaises(TypeError, deque, 'abc', 2)
  256.         self.assertRaises(TypeError, deque, 1)
  257.  
  258.     
  259.     def test_hash(self):
  260.         self.assertRaises(TypeError, hash, deque('abc'))
  261.  
  262.     
  263.     def test_long_steadystate_queue_popleft(self):
  264.         for size in (0, 1, 2, 100, 1000):
  265.             d = deque(xrange(size))
  266.             append = d.append
  267.             pop = d.popleft
  268.             for i in xrange(size, BIG):
  269.                 append(i)
  270.                 x = pop()
  271.                 if x != i - size:
  272.                     self.assertEqual(x, i - size)
  273.                     continue
  274.             
  275.             self.assertEqual(list(d), range(BIG - size, BIG))
  276.         
  277.  
  278.     
  279.     def test_long_steadystate_queue_popright(self):
  280.         for size in (0, 1, 2, 100, 1000):
  281.             d = deque(reversed(xrange(size)))
  282.             append = d.appendleft
  283.             pop = d.pop
  284.             for i in xrange(size, BIG):
  285.                 append(i)
  286.                 x = pop()
  287.                 if x != i - size:
  288.                     self.assertEqual(x, i - size)
  289.                     continue
  290.             
  291.             self.assertEqual(list(reversed(list(d))), range(BIG - size, BIG))
  292.         
  293.  
  294.     
  295.     def test_big_queue_popleft(self):
  296.         d = deque()
  297.         append = d.append
  298.         pop = d.popleft
  299.         for i in xrange(BIG):
  300.             append(i)
  301.         
  302.         for i in xrange(BIG):
  303.             x = pop()
  304.             if x != i:
  305.                 self.assertEqual(x, i)
  306.                 continue
  307.         
  308.  
  309.     
  310.     def test_big_queue_popright(self):
  311.         d = deque()
  312.         append = d.appendleft
  313.         pop = d.pop
  314.         for i in xrange(BIG):
  315.             append(i)
  316.         
  317.         for i in xrange(BIG):
  318.             x = pop()
  319.             if x != i:
  320.                 self.assertEqual(x, i)
  321.                 continue
  322.         
  323.  
  324.     
  325.     def test_big_stack_right(self):
  326.         d = deque()
  327.         append = d.append
  328.         pop = d.pop
  329.         for i in xrange(BIG):
  330.             append(i)
  331.         
  332.         for i in reversed(xrange(BIG)):
  333.             x = pop()
  334.             if x != i:
  335.                 self.assertEqual(x, i)
  336.                 continue
  337.         
  338.         self.assertEqual(len(d), 0)
  339.  
  340.     
  341.     def test_big_stack_left(self):
  342.         d = deque()
  343.         append = d.appendleft
  344.         pop = d.popleft
  345.         for i in xrange(BIG):
  346.             append(i)
  347.         
  348.         for i in reversed(xrange(BIG)):
  349.             x = pop()
  350.             if x != i:
  351.                 self.assertEqual(x, i)
  352.                 continue
  353.         
  354.         self.assertEqual(len(d), 0)
  355.  
  356.     
  357.     def test_roundtrip_iter_init(self):
  358.         d = deque(xrange(200))
  359.         e = deque(d)
  360.         self.assertNotEqual(id(d), id(e))
  361.         self.assertEqual(list(d), list(e))
  362.  
  363.     
  364.     def test_pickle(self):
  365.         d = deque(xrange(200))
  366.         for i in (0, 1, 2):
  367.             s = pickle.dumps(d, i)
  368.             e = pickle.loads(s)
  369.             self.assertNotEqual(id(d), id(e))
  370.             self.assertEqual(list(d), list(e))
  371.         
  372.  
  373.     
  374.     def test_pickle_recursive(self):
  375.         d = deque('abc')
  376.         d.append(d)
  377.         for i in (0, 1, 2):
  378.             e = pickle.loads(pickle.dumps(d, i))
  379.             self.assertNotEqual(id(d), id(e))
  380.             self.assertEqual(id(e), id(e[-1]))
  381.         
  382.  
  383.     
  384.     def test_deepcopy(self):
  385.         mut = [
  386.             10]
  387.         d = deque([
  388.             mut])
  389.         e = copy.deepcopy(d)
  390.         self.assertEqual(list(d), list(e))
  391.         mut[0] = 11
  392.         self.assertNotEqual(id(d), id(e))
  393.         self.assertNotEqual(list(d), list(e))
  394.  
  395.     
  396.     def test_copy(self):
  397.         mut = [
  398.             10]
  399.         d = deque([
  400.             mut])
  401.         e = copy.copy(d)
  402.         self.assertEqual(list(d), list(e))
  403.         mut[0] = 11
  404.         self.assertNotEqual(id(d), id(e))
  405.         self.assertEqual(list(d), list(e))
  406.  
  407.     
  408.     def test_reversed(self):
  409.         for s in ('abcd', xrange(2000)):
  410.             self.assertEqual(list(reversed(deque(s))), list(reversed(s)))
  411.         
  412.  
  413.     
  414.     def test_gc_doesnt_blowup(self):
  415.         import gc as gc
  416.         d = deque()
  417.         for i in xrange(100):
  418.             d.append(1)
  419.             gc.collect()
  420.         
  421.  
  422.  
  423.  
  424. def R(seqn):
  425.     '''Regular generator'''
  426.     for i in seqn:
  427.         yield i
  428.     
  429.  
  430.  
  431. class G:
  432.     '''Sequence using __getitem__'''
  433.     
  434.     def __init__(self, seqn):
  435.         self.seqn = seqn
  436.  
  437.     
  438.     def __getitem__(self, i):
  439.         return self.seqn[i]
  440.  
  441.  
  442.  
  443. class I:
  444.     '''Sequence using iterator protocol'''
  445.     
  446.     def __init__(self, seqn):
  447.         self.seqn = seqn
  448.         self.i = 0
  449.  
  450.     
  451.     def __iter__(self):
  452.         return self
  453.  
  454.     
  455.     def next(self):
  456.         if self.i >= len(self.seqn):
  457.             raise StopIteration
  458.         
  459.         v = self.seqn[self.i]
  460.         self.i += 1
  461.         return v
  462.  
  463.  
  464.  
  465. class Ig:
  466.     '''Sequence using iterator protocol defined with a generator'''
  467.     
  468.     def __init__(self, seqn):
  469.         self.seqn = seqn
  470.         self.i = 0
  471.  
  472.     
  473.     def __iter__(self):
  474.         for val in self.seqn:
  475.             yield val
  476.         
  477.  
  478.  
  479.  
  480. class X:
  481.     '''Missing __getitem__ and __iter__'''
  482.     
  483.     def __init__(self, seqn):
  484.         self.seqn = seqn
  485.         self.i = 0
  486.  
  487.     
  488.     def next(self):
  489.         if self.i >= len(self.seqn):
  490.             raise StopIteration
  491.         
  492.         v = self.seqn[self.i]
  493.         self.i += 1
  494.         return v
  495.  
  496.  
  497.  
  498. class N:
  499.     '''Iterator missing next()'''
  500.     
  501.     def __init__(self, seqn):
  502.         self.seqn = seqn
  503.         self.i = 0
  504.  
  505.     
  506.     def __iter__(self):
  507.         return self
  508.  
  509.  
  510.  
  511. class E:
  512.     '''Test propagation of exceptions'''
  513.     
  514.     def __init__(self, seqn):
  515.         self.seqn = seqn
  516.         self.i = 0
  517.  
  518.     
  519.     def __iter__(self):
  520.         return self
  521.  
  522.     
  523.     def next(self):
  524.         3 // 0
  525.  
  526.  
  527.  
  528. class S:
  529.     '''Test immediate stop'''
  530.     
  531.     def __init__(self, seqn):
  532.         pass
  533.  
  534.     
  535.     def __iter__(self):
  536.         return self
  537.  
  538.     
  539.     def next(self):
  540.         raise StopIteration
  541.  
  542.  
  543. from itertools import chain, imap
  544.  
  545. def L(seqn):
  546.     '''Test multiple tiers of iterators'''
  547.     return chain(imap((lambda x: x), R(Ig(G(seqn)))))
  548.  
  549.  
  550. class TestVariousIteratorArgs(unittest.TestCase):
  551.     
  552.     def test_constructor(self):
  553.         for s in ('123', '', range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
  554.             for g in (G, I, Ig, S, L, R):
  555.                 self.assertEqual(list(deque(g(s))), list(g(s)))
  556.             
  557.             self.assertRaises(TypeError, deque, X(s))
  558.             self.assertRaises(TypeError, deque, N(s))
  559.             self.assertRaises(ZeroDivisionError, deque, E(s))
  560.         
  561.  
  562.     
  563.     def test_iter_with_altered_data(self):
  564.         d = deque('abcdefg')
  565.         it = iter(d)
  566.         d.pop()
  567.         self.assertRaises(RuntimeError, it.next)
  568.  
  569.  
  570.  
  571. class Deque(deque):
  572.     pass
  573.  
  574.  
  575. class DequeWithBadIter(deque):
  576.     
  577.     def __iter__(self):
  578.         raise TypeError
  579.  
  580.  
  581.  
  582. class TestSubclass(unittest.TestCase):
  583.     
  584.     def test_basics(self):
  585.         d = Deque(xrange(100))
  586.         d.__init__(xrange(100, 200))
  587.         for i in xrange(200, 400):
  588.             d.append(i)
  589.         
  590.         for i in reversed(xrange(-200, 0)):
  591.             d.appendleft(i)
  592.         
  593.         self.assertEqual(list(d), range(-200, 400))
  594.         self.assertEqual(len(d), 600)
  595.         left = [ d.popleft() for i in xrange(250) ]
  596.         self.assertEqual(left, range(-200, 50))
  597.         self.assertEqual(list(d), range(50, 400))
  598.         right = [ d.pop() for i in xrange(250) ]
  599.         right.reverse()
  600.         self.assertEqual(right, range(150, 400))
  601.         self.assertEqual(list(d), range(50, 150))
  602.         d.clear()
  603.         self.assertEqual(len(d), 0)
  604.  
  605.     
  606.     def test_copy_pickle(self):
  607.         d = Deque('abc')
  608.         e = d.__copy__()
  609.         self.assertEqual(type(d), type(e))
  610.         self.assertEqual(list(d), list(e))
  611.         e = Deque(d)
  612.         self.assertEqual(type(d), type(e))
  613.         self.assertEqual(list(d), list(e))
  614.         s = pickle.dumps(d)
  615.         e = pickle.loads(s)
  616.         self.assertNotEqual(id(d), id(e))
  617.         self.assertEqual(type(d), type(e))
  618.         self.assertEqual(list(d), list(e))
  619.  
  620.     
  621.     def test_pickle(self):
  622.         d = Deque('abc')
  623.         d.append(d)
  624.         e = pickle.loads(pickle.dumps(d))
  625.         self.assertNotEqual(id(d), id(e))
  626.         self.assertEqual(type(d), type(e))
  627.         dd = d.pop()
  628.         ee = e.pop()
  629.         self.assertEqual(id(e), id(ee))
  630.         self.assertEqual(d, e)
  631.         d.x = d
  632.         e = pickle.loads(pickle.dumps(d))
  633.         self.assertEqual(id(e), id(e.x))
  634.         d = DequeWithBadIter('abc')
  635.         self.assertRaises(TypeError, pickle.dumps, d)
  636.  
  637.     
  638.     def test_weakref(self):
  639.         d = deque('gallahad')
  640.         p = proxy(d)
  641.         self.assertEqual(str(p), str(d))
  642.         d = None
  643.         self.assertRaises(ReferenceError, str, p)
  644.  
  645.     
  646.     def test_strange_subclass(self):
  647.         
  648.         class X(deque):
  649.             
  650.             def __iter__(self):
  651.                 return iter([])
  652.  
  653.  
  654.         d1 = X([
  655.             1,
  656.             2,
  657.             3])
  658.         d2 = X([
  659.             4,
  660.             5,
  661.             6])
  662.         d1 == d2
  663.  
  664.  
  665. libreftest = '\nExample from the Library Reference:  Doc/lib/libcollections.tex\n\n>>> from collections import deque\n>>> d = deque(\'ghi\')                 # make a new deque with three items\n>>> for elem in d:                   # iterate over the deque\'s elements\n...     print elem.upper()\nG\nH\nI\n>>> d.append(\'j\')                    # add a new entry to the right side\n>>> d.appendleft(\'f\')                # add a new entry to the left side\n>>> d                                # show the representation of the deque\ndeque([\'f\', \'g\', \'h\', \'i\', \'j\'])\n>>> d.pop()                          # return and remove the rightmost item\n\'j\'\n>>> d.popleft()                      # return and remove the leftmost item\n\'f\'\n>>> list(d)                          # list the contents of the deque\n[\'g\', \'h\', \'i\']\n>>> d[0]                             # peek at leftmost item\n\'g\'\n>>> d[-1]                            # peek at rightmost item\n\'i\'\n>>> list(reversed(d))                # list the contents of a deque in reverse\n[\'i\', \'h\', \'g\']\n>>> \'h\' in d                         # search the deque\nTrue\n>>> d.extend(\'jkl\')                  # add multiple elements at once\n>>> d\ndeque([\'g\', \'h\', \'i\', \'j\', \'k\', \'l\'])\n>>> d.rotate(1)                      # right rotation\n>>> d\ndeque([\'l\', \'g\', \'h\', \'i\', \'j\', \'k\'])\n>>> d.rotate(-1)                     # left rotation\n>>> d\ndeque([\'g\', \'h\', \'i\', \'j\', \'k\', \'l\'])\n>>> deque(reversed(d))               # make a new deque in reverse order\ndeque([\'l\', \'k\', \'j\', \'i\', \'h\', \'g\'])\n>>> d.clear()                        # empty the deque\n>>> d.pop()                          # cannot pop from an empty deque\nTraceback (most recent call last):\n  File "<pyshell#6>", line 1, in -toplevel-\n    d.pop()\nIndexError: pop from an empty deque\n\n>>> d.extendleft(\'abc\')              # extendleft() reverses the input order\n>>> d\ndeque([\'c\', \'b\', \'a\'])\n\n\n\n>>> def delete_nth(d, n):\n...     d.rotate(-n)\n...     d.popleft()\n...     d.rotate(n)\n...\n>>> d = deque(\'abcdef\')\n>>> delete_nth(d, 2)   # remove the entry at d[2]\n>>> d\ndeque([\'a\', \'b\', \'d\', \'e\', \'f\'])\n\n\n\n>>> def roundrobin(*iterables):\n...     pending = deque(iter(i) for i in iterables)\n...     while pending:\n...         task = pending.popleft()\n...         try:\n...             yield task.next()\n...         except StopIteration:\n...             continue\n...         pending.append(task)\n...\n\n>>> for value in roundrobin(\'abc\', \'d\', \'efgh\'):\n...     print value\n...\na\nd\ne\nb\nf\nc\ng\nh\n\n\n>>> def maketree(iterable):\n...     d = deque(iterable)\n...     while len(d) > 1:\n...         pair = [d.popleft(), d.popleft()]\n...         d.append(pair)\n...     return list(d)\n...\n>>> print maketree(\'abcdefgh\')\n[[[[\'a\', \'b\'], [\'c\', \'d\']], [[\'e\', \'f\'], [\'g\', \'h\']]]]\n\n'
  666. __test__ = {
  667.     'libreftest': libreftest }
  668.  
  669. def test_main(verbose = None):
  670.     import sys as sys
  671.     test_classes = (TestBasic, TestVariousIteratorArgs, TestSubclass)
  672.     test_support.run_unittest(*test_classes)
  673.     if verbose and hasattr(sys, 'gettotalrefcount'):
  674.         import gc
  675.         counts = [
  676.             None] * 5
  677.         for i in xrange(len(counts)):
  678.             test_support.run_unittest(*test_classes)
  679.             gc.collect()
  680.             counts[i] = sys.gettotalrefcount()
  681.         
  682.         print counts
  683.     
  684.     test_deque = test_deque
  685.     import test
  686.     test_support.run_doctest(test_deque, verbose)
  687.  
  688. if __name__ == '__main__':
  689.     test_main(verbose = True)
  690.  
  691.